/**
 * 批次等效计算工具 - 统一封装版
 */

/**
 * 计算等效位差主函数
 * @param {Array} dataList - 院校/专业数据列表
 * @param {Object} batchEqus - 批次等效数据
 * @returns {Array} 处理后的数据列表
 */
export const calculateEquivalents = (dataList, batchEqus) => {
  // 1. 参数校验
  if (!Array.isArray(dataList)) {
    console.error('calculateEquivalents: dataList必须是一个数组');
    return dataList || [];
  }

  if (!batchEqus || typeof batchEqus !== 'object') {
    console.error('calculateEquivalents: batchEqus必须是一个对象');
    return dataList;
  }

  // 2. 深拷贝数据避免污染原数据
  const processedList = JSON.parse(JSON.stringify(dataList));

  // 3. 处理每所院校数据
  processedList.forEach((institution) => {
    // 处理院校层级数据
    processInstitutionData(institution, batchEqus);

    // 处理专业层级数据
    if (institution.majorsInfo?.length) {
      institution.majorsInfo.forEach((major) => {
        processInstitutionData(major, batchEqus, institution.batch);
      });
    }
  });

  return processedList;
};

/**
 * 处理院校/专业数据
 * @param {Object} item - 院校或专业数据
 * @param {Object} batchEqus - 批次等效数据
 * @param {string} [parentBatch] - 父级批次（用于专业数据）
 */
const processInstitutionData = (item, batchEqus, parentBatch) => {
  const batch = item.batch || parentBatch;

  if (item.moreYear?.length) {
    item.moreYear.forEach((yearData) => {
      calculateEquivalentBitDifference(yearData, batchEqus, batch);
    });
  }
};

/**
 * 计算等效位差核心逻辑
 * @param {Object} item - 年份数据项
 * @param {Object} batchEqus - 批次等效数据
 * @param {string} batch - 批次名称
 */
const calculateEquivalentBitDifference = (item, batchEqus, batch) => {
  // 设置默认值
  item.equivalentBitDifference = '-';

  // 只有有招生计划时才计算
  if (!item.hasPlan) return;

  try {
    const minRankArr = item.minRank?.toString().split('/').slice(0, 2) || [];

    if (minRankArr.length === 1) {
      // 单个值情况
      handleSingleRank(item, batchEqus, batch);
    } else {
      // 多个值情况
      handleMultipleRanks(item, batchEqus, batch, minRankArr);
    }
  } catch (error) {
    console.error('计算等效位差出错:', error);
  }
};

/**
 * 处理单个排名值
 */
const handleSingleRank = (item, batchEqus, batch) => {
  const batchEqScore = getBatchEqScore(item.year, batch, batchEqus);

  if (isValidForCalculation(item.minRank, batchEqScore)) {
    item.equivalentBitDifference = String(Number(item.minRank) - batchEqScore);
  }
};

/**
 * 处理多个排名值
 */
const handleMultipleRanks = (item, batchEqus, batch, minRankArr) => {
  const batchStr = (item.batch || batch)?.toString() || '';
  const allBatches = batchStr.split('/');

  // 只取前 minRankArr.length 个批次进行匹配
  const batchArr = allBatches.slice(0, minRankArr.length);

  const batchEqScoreArr = batchArr.map((batchItem) =>
    // batchEqus.batchs[batch]  如果取不到，就用院校的batch去匹配
    getBatchEqScore(item.year, batchItem, batchEqus, batchEqus.batchs[batch]),
  );

  if (batchEqScoreArr.every((score) => score != null)) {
    item.equivalentBitDifference = calculateArrayDifferences(
      minRankArr,
      batchEqScoreArr,
    );
  }
};

/**
 * 获取批次等效分数
 */
const getBatchEqScore = (year, batch, batchEqusData, managerBatch) => {
  if (!batchEqusData?.batchs || !batch || !year) return null;

  const category = batchEqusData.batchs[batch] || managerBatch;
  // if (!category) return null;

  return batchEqusData[category]?.[year]?.eqRank ?? null;
};

/**
 * 计算数组差值
 */
const calculateArrayDifferences = (minRanks, eqScores) => {
  return minRanks
    .map((rank, index) => {
      const a = Number(rank);
      const b = Number(eqScores[index]);
      return !isNaN(a) && !isNaN(b) ? String(a - b) : '-';
    })
    .join('/');
};

/**
 * 验证是否可以进行计算
 */
const isValidForCalculation = (minRank, eqScore) => {
  return (
    eqScore != null &&
    minRank &&
    minRank !== '0' &&
    minRank !== '-' &&
    !isNaN(Number(minRank))
  );
};
